# Dataset Configuration
import os

# Dataset parameters
endpoint_url = "https://sparql.wikipathways.org/sparql/"
dataset_name = "wikipathways"
void_iri = "http://rdf.wikipathways.org/"
graph_uri = "http://rdf.wikipathways.org/"

# Setup paths
working_path = os.path.abspath("")
exports_path = os.path.join(
    working_path, "..", "..", "docs", "data", "schema_extraction", dataset_name
)
os.makedirs(exports_path, exist_ok=True)

import logging
import sys

# Minimal notebook logger using existing dataset_name
logger = logging.getLogger(dataset_name or "notebook")
logger.setLevel(logging.DEBUG)  # Set to DEBUG to see SPARQL queries

# Also configure the rdfsolve.parser logger to see query details
parser_logger = logging.getLogger("rdfsolve.parser")
parser_logger.setLevel(logging.DEBUG)

# Avoid adding duplicate handlers if the cell is re-run
if not logger.handlers:
    fmt = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S")

    sh = logging.StreamHandler(sys.stdout)
    sh.setLevel(logging.DEBUG)  # Set to DEBUG to see all logs
    sh.setFormatter(fmt)
    logger.addHandler(sh)

    # Add the same handler to the parser logger
    parser_logger.addHandler(sh)

logger.info(f"Logging configured for {dataset_name}")

2026-01-16 13:39:18 INFO wikipathways: Logging configured for wikipathways

# Import libraries
import json

# Configure Plotly for HTML output
import plotly.io as pio
import plotly.offline as pyo
from IPython.display import Markdown, display

# Import rdfsolve API functions
from rdfsolve.api import (
    discover_void_graphs,
    generate_void_from_endpoint,
    load_parser_from_graph,
    retrieve_void_from_graphs,
)
from rdfsolve.sparql_helper import SparqlHelper

# Enable query collection to track all SPARQL queries executed
SparqlHelper.enable_query_collection()

# Set renderer to 'notebook' for Jupyter, but ensure HTML export works
pio.renderers.default = "notebook+plotly_mimetype"

# Initialize offline mode for Plotly
pyo.init_notebook_mode(connected=True)

# Pickle caching utilities
import os
import pickle


def save_cache(data, filename, cache_dir=None):
    """Save data to pickle cache."""
    if cache_dir is None:
        cache_dir = os.path.join(exports_path, "cache")
    os.makedirs(cache_dir, exist_ok=True)

    cache_path = os.path.join(cache_dir, f"{filename}.pkl")
    with open(cache_path, "wb") as f:
        pickle.dump(data, f)
    print(f"Cached data to: {cache_path}")
    return cache_path


def load_cache(filename, cache_dir=None):
    """Load data from pickle cache if it exists."""
    if cache_dir is None:
        cache_dir = os.path.join(exports_path, "cache")

    cache_path = os.path.join(cache_dir, f"{filename}.pkl")
    if os.path.exists(cache_path):
        with open(cache_path, "rb") as f:
            data = pickle.load(f)
        print(f"Loaded cached data from: {cache_path}")
        return data
    return None


def cache_exists(filename, cache_dir=None):
    """Check if cache file exists."""
    if cache_dir is None:
        cache_dir = os.path.join(exports_path, "cache")

    cache_path = os.path.join(cache_dir, f"{filename}.pkl")
    return os.path.exists(cache_path)

# Cache management utilities
def list_cache_files(cache_dir=None):
    """List all cache files."""
    if cache_dir is None:
        cache_dir = os.path.join(exports_path, "cache")

    if not os.path.exists(cache_dir):
        print("No cache directory found")
        return []

    cache_files = [f for f in os.listdir(cache_dir) if f.endswith(".pkl")]
    print(f"Cache directory: {cache_dir}")
    for f in cache_files:
        file_path = os.path.join(cache_dir, f)
        size_mb = os.path.getsize(file_path) / (1024 * 1024)
        print(f"  {f} ({size_mb:.2f} MB)")
    return cache_files


def clear_cache(filename=None, cache_dir=None):
    """Clear specific cache file or all cache."""
    if cache_dir is None:
        cache_dir = os.path.join(exports_path, "cache")

    if filename:
        cache_path = os.path.join(cache_dir, f"{filename}.pkl")
        if os.path.exists(cache_path):
            os.remove(cache_path)
            print(f"Removed cache: {filename}")
        else:
            print(f"Cache not found: {filename}")
    else:
        # Clear all cache files
        if os.path.exists(cache_dir):
            import shutil

            shutil.rmtree(cache_dir)
            print("Cleared all cache files")
        else:
            print("No cache directory to clear")


# Show current cache status
list_cache_files()

No cache directory found

[]

# Clear specific cache files (uncomment lines as needed for testing)

# When testing new VoID discovery/generation:
# clear_cache(f"{dataset_name}_voidgraph")

# When testing JSON-LD generation (primary output):
# clear_cache(f"{dataset_name}_jsonld_schema")

# When testing frequency calculations:
# clear_cache(f"{dataset_name}_frequencies_basic")
# clear_cache(f"{dataset_name}_frequencies_with_instances")

# Clear everything:
clear_cache()

print("Cache control ready")
print("Note: VoID graph and JSON-LD are the primary caches")

No cache directory to clear
Cache control ready
Note: VoID graph and JSON-LD are the primary caches

cache_key = f"{dataset_name}_voidgraph"
void_graph = load_cache(cache_key)

if void_graph is None:
    discovery_result = discover_void_graphs(
        endpoint_url, graph_uris=[graph_uri] if graph_uri else None
    )

    found_graphs = discovery_result.get("found_graphs", [])
    partitions = discovery_result.get("partitions", [])

    if found_graphs and partitions:
        print(f"Found {len(found_graphs)} VoID graphs with {len(partitions)} partitions")
        void_graph = retrieve_void_from_graphs(
            endpoint_url,
            found_graphs,
            graph_uris=[graph_uri] if graph_uri else None,
            partitions=partitions,
        )
        void_path = os.path.join(exports_path, f"{dataset_name}_discovered_void.ttl")
        void_graph.serialize(destination=void_path, format="turtle")
        print(f"Saved discovered VoID to: {void_path}")
    else:
        print("No VoID found, generating from endpoint...")
        void_graph = generate_void_from_endpoint(
            endpoint_url=endpoint_url,
            graph_uris=[graph_uri] if graph_uri else None,
            output_file=os.path.join(exports_path, f"{dataset_name}_generated_void.ttl"),
            counts=True,
            offset_limit_steps=300,
            exclude_graphs=True,
        )

    save_cache(void_graph, cache_key)
    print(f"Cached VoID graph ({len(void_graph)} triples)")
else:
    print(f"Loaded from cache ({len(void_graph)} triples)")

vp = load_parser_from_graph(void_graph, graph_uris=[graph_uri] if graph_uri else None)

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Starting VoID partition discovery for https://sparql.wikipathways.org/sparql/

2026-01-16 13:39:23 INFO rdfsolve.parser: Discovering VoID partitions across all graphs

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Discovery complete: found 0 graphs with VoID partitions

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Collected 0 partition records

No VoID found, generating from endpoint...
2026-01-16 13:39:23 DEBUG rdfsolve.parser: Replacing graph clause, graph_uris=['http://rdf.wikipathways.org/']

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Query has #GRAPH_CLAUSE: True

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Single graph: GRAPH <http://rdf.wikipathways.org/> {

2026-01-16 13:39:23 DEBUG rdfsolve.parser: After replacement has #GRAPH_CLAUSE: False

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Replacing graph clause, graph_uris=['http://rdf.wikipathways.org/']

2026-01-16 13:39:23 DEBUG rdfsolve.parser: Query has #GRAPH_CLAUSE: True

# Primary JSON-LD schema export and basic summary
cache_key = f"{dataset_name}_jsonld_schema"
jsonld_schema = load_cache(cache_key)

if jsonld_schema is None:
    print("Generating JSON-LD schema...")
    jsonld_schema = vp.to_jsonld(filter_void_admin_nodes=True)
    save_cache(jsonld_schema, cache_key)
else:
    print("Loaded JSON-LD schema from cache")

# Save JSON-LD schema file
jsonld_file = os.path.join(exports_path, f"{dataset_name}_schema.jsonld")
with open(jsonld_file, "w", encoding="utf-8") as f:
    json.dump(jsonld_schema, f, indent=2, ensure_ascii=False)

print(f"JSON-LD Schema saved to: {jsonld_file}")

# Display combined JSON-LD structure info and schema summary
if "@graph" in jsonld_schema:
    print("\nSchema Summary:")
    print(f"   • Prefixes: {len(jsonld_schema['@context'])}")
    print(f"   • Resources: {len(jsonld_schema['@graph'])}")

    # Show dataset metadata
    dataset_info = jsonld_schema["@graph"][0] if jsonld_schema["@graph"] else {}
    if dataset_info.get("@type") == "void:Dataset":
        print(f"   • Dataset: {dataset_info.get('dcterms:title', 'Unknown')}")
        print(f"   • Classes: {dataset_info.get('void:classes', 0)}")
        print(f"   • Properties: {dataset_info.get('void:properties', 0)}")
        print(f"   • Triples: {dataset_info.get('void:triples', 0)}")

# Get schema DataFrame and show sample
schema_df = vp.to_schema(filter_void_admin_nodes=True)
print(f"\nSchema Patterns Preview ({len(schema_df)} total):")
display(schema_df.head())

Loaded cached data from: /home/javi/rdfsolve-1/notebooks/01_schema_extraction/../../docs/data/schema_extraction/wikipathways/cache/wikipathways_jsonld_schema.pkl
Loaded JSON-LD schema from cache
JSON-LD Schema saved to: /home/javi/rdfsolve-1/notebooks/01_schema_extraction/../../docs/data/schema_extraction/wikipathways/wikipathways_schema.jsonld

Schema Summary:
   • Prefixes: 13
   • Resources: 38
2026-01-16 13:40:06 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:06 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:06 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:06 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:06 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

# Schema pattern coverage analysis and export
cache_key = f"{dataset_name}_frequencies_basic"
cached_data = load_cache(cache_key)

if cached_data is None:
    print("Calculating schema pattern frequencies...")
    frequencies_df, _ = vp.count_schema_shape_frequencies(
        endpoint_url=endpoint_url,
        offset_limit_steps=300,
    )
    save_cache(frequencies_df, cache_key)
else:
    print("Loaded frequencies DataFrame from cache")
    frequencies_df = cached_data

# Export coverage analysis
frequencies_output_path = os.path.join(exports_path, f"{dataset_name}_pattern_coverage.csv")
exported_df = vp.export_schema_shape_frequencies(
    frequencies_df, output_file=frequencies_output_path
)

# Combined summary and sample
if not frequencies_df.empty:
    avg_coverage = frequencies_df["coverage_percent"].mean()
    high_coverage = (frequencies_df["coverage_percent"] > 50).sum()

    print("\nPattern Coverage Analysis:")
    print(f"   • Total patterns: {len(frequencies_df)}")
    print(f"   • Average coverage: {avg_coverage:.1f}%")
    print(f"   • High coverage (>50%): {high_coverage}")
    print(f"   • Exported to: {frequencies_output_path}")

    print("\nSample Coverage Data:")
    display(
        frequencies_df[["subject_class", "property", "object_class", "coverage_percent"]].head()
    )

    print("\nCoverage Statistics:")
    display(frequencies_df["coverage_percent"].describe())
else:
    print("No frequency data available")

Calculating schema pattern frequencies...
2026-01-16 13:40:07 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:07 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:07 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:07 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:40:07 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

# Collect both frequency data and actual instances with caching
cache_key = f"{dataset_name}_frequencies_with_instances"
cached_data = load_cache(cache_key)

if cached_data is None:
    print("Collecting frequency data and instances...")
    frequencies_with_instances_df, instances_df = vp.count_schema_shape_frequencies(
        endpoint_url=endpoint_url,
        # sample_limit=100,  # Limited sample for demonstration
        collect_instances=True,
        offset_limit_steps=300,
    )
    # Cache both DataFrames as a tuple
    save_cache((frequencies_with_instances_df, instances_df), cache_key)
else:
    print("Loaded frequencies and instances DataFrames from cache")
    frequencies_with_instances_df, instances_df = cached_data

# Display basic information about the data structure
print(f"Frequencies DataFrame: {len(frequencies_with_instances_df)} shapes")
if instances_df is not None:
    print(f"Instances DataFrame: {len(instances_df)} relationships")
    print(f"Memory usage: {instances_df.memory_usage(deep=True).sum() / 1024 / 1024:.1f} MB")

    # Export instances in compact format
    instances_prefix = os.path.join(exports_path, f"{dataset_name}_instances")
    export_result = vp.export_instances_compact(instances_df, instances_prefix)
    print(f"Exported instances: {export_result['total_relationships']} relationships")
    print(f"   • Subject index: {export_result['total_subjects']} unique subjects")
    print(f"   • Object index: {export_result['total_objects']} unique objects")
    print(
        f"   • Total size: {sum([export_result['subject_index_size_mb'], export_result['object_index_size_mb'], export_result['instances_jsonl_size_mb']]):.2f} MB"
    )
else:
    print("No instances collected")

Collecting frequency data and instances...
2026-01-16 13:48:53 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:48:53 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:48:53 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:48:53 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 13:48:53 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

# Export instances in compact format
if instances_df is not None:
    instances_prefix = os.path.join(exports_path, f"{dataset_name}_instances")
    export_result = vp.export_instances_compact(instances_df, instances_prefix)
    print(f"\nExported instances: {export_result['total_relationships']} relationships")
    print(f"   • Subject index: {export_result['total_subjects']} unique subjects")
    print(f"   • Object index: {export_result['total_objects']} unique objects")
    print(
        f"   • Total size: {sum([export_result['subject_index_size_mb'], export_result['object_index_size_mb'], export_result['instances_jsonl_size_mb']]):.2f} MB"
    )

Exported instances: 1821835 relationships
   • Subject index: 527740 unique subjects
   • Object index: 221867 unique objects
   • Total size: 453.92 MB

import pandas as pd
import plotly.graph_objects as go

if not frequencies_with_instances_df.empty:
    df = frequencies_with_instances_df.copy()
    df["coverage_percent"] = pd.to_numeric(df["coverage_percent"], errors="coerce").fillna(0)
    df = df.sort_values("coverage_percent", ascending=False).reset_index(drop=True)

    def make_label(row):
        return (
            f"<b>{row['subject_class']}</b> "
            f"<span style='color:#888;'></span> "
            f"<i>{row['property']}</i> "
            f"<span style='color:#888;'></span> "
            f"<b>{row['object_class']}</b>"
        )

    df["styled_label"] = df.apply(make_label, axis=1)

    text_positions = ["outside" if v < 95 else "inside" for v in df["coverage_percent"]]
    custom_colorscale = [
        [0.0, "#d36e61"],
        [0.4, "#e5cdbd"],
        [0.7, "#e8e4cf"],
        [1.0, "#c3d9c0"],
    ]

    # Figure sizing
    bar_height = 26
    fig_height = min(2000, bar_height * len(df) + 200)

    fig = go.Figure(
        go.Bar(
            x=df["coverage_percent"],
            y=df["styled_label"],
            orientation="h",
            text=[f"{v:.1f}%" for v in df["coverage_percent"]],
            textposition=text_positions,
            marker={
                "color": df["coverage_percent"],
                "colorscale": custom_colorscale,
                "cmin": 0,
                "cmax": 100,
                "line": {"color": "white", "width": 0.6},
            },
            hovertemplate="<b>%{y}</b><br>Coverage: %{x:.1f}%<extra></extra>",
        )
    )

    fig.update_layout(
        title={
            "text": f"Schema Pattern Coverage for {dataset_name}",
            "x": 0.5,
            "font": {"size": 18},
        },
        xaxis={
            "title": "Coverage (%)",
            "range": [0, 100],  # fixed x-axis range
            "ticksuffix": "%",
            "showgrid": True,
            "gridcolor": "rgba(220,220,220,0.3)",
        },
        yaxis={
            "title": "",
            "autorange": "reversed",
            "automargin": True,
            "fixedrange": False,  # allow vertical zoom/pan
        },
        template="plotly_white",
        autosize=True,  # allow figure to scale with container
        height=fig_height,  # base height (will scale)
        margin={"t": 80, "b": 50, "l": 480, "r": 150},  # extra right margin for text
        plot_bgcolor="white",
        paper_bgcolor="white",
    )

    # Disable horizontal zoom/pan
    fig.update_xaxes(fixedrange=True)

    # Show figure with config for HTML export compatibility
    fig.show(
        config={
            "scrollZoom": True,
            "responsive": True,
            "toImageButtonOptions": {
                "format": "png",
                "filename": f"{dataset_name}_schema_coverage",
                "height": fig_height,
                "width": 600,
                "scale": 1,
            },
        }
    )

else:
    display(Markdown("**No coverage data to visualize**"))

# Generate LinkML directly from JSON-LD with custom schema URI
print("Regenerating LinkML schema from JSON-LD with custom schema URI...")

schema_name = f"{dataset_name}_schema"
custom_schema_uri = (
    f"http://jmillanacosta.github.io/rdfsolve/{dataset_name}/linkml"  # User-definable base URI
)

yaml_text = vp.to_linkml_yaml(
    schema_name=schema_name,
    schema_description=f"LinkML schema for {dataset_name} generated from JSON-LD",
    schema_base_uri=custom_schema_uri,
    filter_void_nodes=True,
)

# Save to LinkML YAML
linkml_file = os.path.join(exports_path, f"{dataset_name}_linkml_schema.yaml")
with open(linkml_file, "w", encoding="utf-8") as f:
    f.write(yaml_text)

print(f"LinkML YAML saved to: {linkml_file}")

Regenerating LinkML schema from JSON-LD with custom schema URI...
2026-01-16 14:12:21 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:21 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:21 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:21 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:21 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

from linkml.generators.erdiagramgen import ERDiagramGenerator
from linkml_runtime.utils.schemaview import SchemaView

sv = SchemaView(linkml_file)
linkml_schema = sv.schema

display(
    Markdown(
        f"**Parsed LinkML schema:** Classes = {len(sv.all_classes())}, Slots = {len(sv.all_slots())}"
    )
)

# Build and display a Mermaid class diagram for the aopwikirdf LinkedML
mermaid_code = ERDiagramGenerator(linkml_file).serialize()

display(Markdown(mermaid_code))

erDiagram
DcatDistribution {

}
FoafImage {

}
FoafPerson {

}
GpmlAnchor {

}
GpmlComment {

}
GpmlDataNode {

}
GpmlGraphicalLine {

}
GpmlGroup {

}
GpmlInfoBox {

}
GpmlInteraction {

}
GpmlLabel {

}
GpmlPoint {

}
GpmlPublicationXref {

}
GpmlShape {

}
GpmlState {

}
OwlAnnotationProperty {

}
OwlAxiom {

}
OwlClass {

}
OwlDatatypeProperty {

}
OwlObjectProperty {

}
OwlOntology {

}
OwlRestriction {

}
SkosCollection {

}
SkosConceptScheme {

}
VoidDataset {

}
VoidDatasetDescription {

}
VoidLinkset {

}
WpBinding {

}
WpCatalysis {

}
WpComplex {

}
WpComplexBinding {

}
WpConversion {

}
WpDataNode {

}
WpDirectedInteraction {

}
WpGeneProduct {

}
WpInhibition {

}
WpInteraction {

}
WpMetabolite {

}
WpPathway {

}
WpProtein {

}
WpPublicationReference {

}
WpRna {

}
WpStimulation {

}
WpTranscriptionTranslation {

}
WpTranslocation {

}

GpmlAnchor ||--|o GpmlGroup : "dcterms_is_Part_Of"
GpmlAnchor ||--|o OwlClass : "rdf_type"
GpmlComment ||--|o GpmlGroup : "dcterms_is_Part_Of"
GpmlDataNode ||--|o GpmlComment : "gpml_has_Comment"
GpmlDataNode ||--|o GpmlGroup : "dcterms_is_Part_Of"
GpmlDataNode ||--|o GpmlPublicationXref : "gpml_has_Publication_Xref"
GpmlGraphicalLine ||--|o GpmlComment : "gpml_has_Comment"
GpmlInfoBox ||--|o OwlClass : "rdf_type"
GpmlInteraction ||--|o GpmlComment : "gpml_has_Comment"
GpmlInteraction ||--|o GpmlGroup : "dcterms_is_Part_Of"
GpmlLabel ||--|o GpmlPublicationXref : "gpml_has_Publication_Xref"
GpmlLabel ||--|o OwlClass : "rdf_type"
GpmlPoint ||--|o GpmlGroup : "dcterms_is_Part_Of"
GpmlPoint ||--|o OwlClass : "rdf_type"
GpmlPublicationXref ||--|o GpmlGroup : "dcterms_is_Part_Of"
GpmlShape ||--|o GpmlComment : "gpml_has_Comment"
GpmlShape ||--|o GpmlPublicationXref : "gpml_has_Publication_Xref"
GpmlState ||--|o GpmlPublicationXref : "gpml_has_Publication_Xref"
OwlAxiom ||--|o OwlAnnotationProperty : "oboinowl_has_Synonym_Type"
OwlClass ||--|o OwlAnnotationProperty : "oboinowl_in_Subset"
OwlClass ||--|o SkosConceptScheme : "skos_in_Scheme"
OwlDatatypeProperty ||--|o SkosConceptScheme : "skos_in_Scheme"
OwlObjectProperty ||--|o SkosConceptScheme : "skos_in_Scheme"
OwlRestriction ||--|o OwlObjectProperty : "owl_on_Property"
SkosCollection ||--|o FoafImage : "foaf_img"
SkosCollection ||--|o WpPathway : "dc_identifier"
SkosCollection ||--|o WpPublicationReference : "dcterms_references"
VoidDataset ||--|o DcatDistribution : "dcat_distribution"
VoidDataset ||--|o OwlClass : "dcterms_subject"
VoidDataset ||--|o OwlOntology : "void_vocabulary"
VoidDataset ||--|o VoidLinkset : "void_subset"
VoidDataset ||--|o WpProtein : "void_example_Resource"
VoidDatasetDescription ||--|o VoidDataset : "foaf_primary_Topic"
VoidLinkset ||--|o OwlObjectProperty : "void_link_Predicate"
WpBinding ||--|o GpmlDataNode : "wp_is_About"
WpBinding ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpBinding ||--|o WpDataNode : "wp_participants"
WpBinding ||--|o WpDirectedInteraction : "wp_target"
WpBinding ||--|o WpPublicationReference : "dcterms_references"
WpBinding ||--|o WpRna : "wp_source"
WpCatalysis ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpCatalysis ||--|o WpDataNode : "wp_participants"
WpCatalysis ||--|o WpDirectedInteraction : "wp_target"
WpCatalysis ||--|o WpPublicationReference : "dcterms_references"
WpCatalysis ||--|o WpRna : "wp_source"
WpComplex ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpComplex ||--|o OwlClass : "rdf_type"
WpComplex ||--|o WpDataNode : "wp_bdb_Reactome"
WpComplex ||--|o WpDataNode : "wp_participants"
WpComplex ||--|o WpGeneProduct : "wp_bdb_Complex_Portal"
WpComplex ||--|o WpGeneProduct : "wp_bdb_Hgnc_Symbol"
WpComplex ||--|o WpGeneProduct : "wp_bdb_Uniprot"
WpComplex ||--|o WpPathway : "wp_bdb_Ensembl"
WpComplex ||--|o WpProtein : "wp_bdb_Entrez_Gene"
WpComplex ||--|o WpPublicationReference : "dcterms_bibliographic_Citation"
WpComplex ||--|o WpPublicationReference : "dcterms_references"
WpComplexBinding ||--|o GpmlDataNode : "wp_is_About"
WpComplexBinding ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpComplexBinding ||--|o OwlClass : "rdf_type"
WpComplexBinding ||--|o WpDataNode : "wp_participants"
WpConversion ||--|o GpmlDataNode : "wp_is_About"
WpConversion ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpConversion ||--|o WpDataNode : "wp_participants"
WpConversion ||--|o WpDirectedInteraction : "wp_target"
WpConversion ||--|o WpPublicationReference : "dcterms_references"
WpConversion ||--|o WpRna : "wp_source"
WpDataNode ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpDataNode ||--|o OwlClass : "rdf_type"
WpDataNode ||--|o WpDataNode : "rdfs_see_Also"
WpDataNode ||--|o WpDataNode : "wp_bdb_Lipid_Maps"
WpDataNode ||--|o WpDataNode : "wp_bdb_Reactome"
WpDataNode ||--|o WpDataNode : "wp_participants"
WpDataNode ||--|o WpMetabolite : "wp_bdb_Ch_EBI"
WpDataNode ||--|o WpMetabolite : "wp_bdb_Hmdb"
WpDataNode ||--|o WpMetabolite : "wp_bdb_Kegg_Compound"
WpDataNode ||--|o WpPathway : "dc_identifier"
WpDataNode ||--|o WpPathway : "wp_bdb_Ensembl"
WpDataNode ||--|o WpProtein : "wp_bdb_Entrez_Gene"
WpDataNode ||--|o WpPublicationReference : "dcterms_bibliographic_Citation"
WpDirectedInteraction ||--|o GpmlDataNode : "wp_is_About"
WpDirectedInteraction ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpDirectedInteraction ||--|o OwlClass : "rdf_type"
WpDirectedInteraction ||--|o WpDataNode : "wp_bdb_Reactome"
WpDirectedInteraction ||--|o WpDataNode : "wp_participants"
WpDirectedInteraction ||--|o WpDirectedInteraction : "wp_target"
WpDirectedInteraction ||--|o WpPublicationReference : "dcterms_references"
WpDirectedInteraction ||--|o WpRna : "wp_source"
WpGeneProduct ||--|o FoafPerson : "dc_creator"
WpGeneProduct ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpGeneProduct ||--|o WpGeneProduct : "wp_bdb_Complex_Portal"
WpGeneProduct ||--|o WpGeneProduct : "wp_bdb_Uniprot"
WpGeneProduct ||--|o WpPathway : "dc_identifier"
WpGeneProduct ||--|o WpPathway : "wp_bdb_Ensembl"
WpGeneProduct ||--|o WpProtein : "wp_bdb_Entrez_Gene"
WpInhibition ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpInhibition ||--|o OwlClass : "rdf_type"
WpInhibition ||--|o WpDataNode : "wp_participants"
WpInhibition ||--|o WpDirectedInteraction : "wp_target"
WpInhibition ||--|o WpMetabolite : "wp_bdb_Hmdb"
WpInhibition ||--|o WpRna : "wp_source"
WpInteraction ||--|o WpDataNode : "wp_bdb_Reactome"
WpInteraction ||--|o WpDataNode : "wp_participants"
WpInteraction ||--|o WpDirectedInteraction : "wp_target"
WpInteraction ||--|o WpPublicationReference : "dcterms_bibliographic_Citation"
WpInteraction ||--|o WpPublicationReference : "dcterms_references"
WpInteraction ||--|o WpRna : "wp_source"
WpMetabolite ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpMetabolite ||--|o WpDataNode : "rdfs_see_Also"
WpMetabolite ||--|o WpDataNode : "wp_bdb_Reactome"
WpMetabolite ||--|o WpMetabolite : "wp_bdb_Chemspider"
WpMetabolite ||--|o WpMetabolite : "wp_bdb_Hmdb"
WpMetabolite ||--|o WpMetabolite : "wp_bdb_In_Ch_IKey"
WpMetabolite ||--|o WpMetabolite : "wp_bdb_Kegg_Compound"
WpMetabolite ||--|o WpPathway : "dc_identifier"
WpPathway ||--|o GpmlDataNode : "wp_is_About"
WpPathway ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpPathway ||--|o OwlClass : "wp_ontology_Tag"
WpPathway ||--|o WpGeneProduct : "wp_bdb_Hgnc_Symbol"
WpPathway ||--|o WpGeneProduct : "wp_bdb_Uniprot"
WpPathway ||--|o WpPathway : "dc_identifier"
WpPathway ||--|o WpPathway : "wp_bdb_Ensembl"
WpPathway ||--|o WpPublicationReference : "cito_cites"
WpPathway ||--|o WpPublicationReference : "dcterms_references"
WpProtein ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpProtein ||--|o OwlClass : "rdf_type"
WpProtein ||--|o WpDataNode : "wp_bdb_Reactome"
WpProtein ||--|o WpGeneProduct : "wp_bdb_Hgnc_Symbol"
WpProtein ||--|o WpGeneProduct : "wp_bdb_Uniprot"
WpProtein ||--|o WpMetabolite : "wp_bdb_Ch_EBI"
WpProtein ||--|o WpPathway : "dc_identifier"
WpProtein ||--|o WpPathway : "wp_bdb_Ensembl"
WpProtein ||--|o WpProtein : "wp_bdb_Entrez_Gene"
WpPublicationReference ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpRna ||--|o GpmlGroup : "dcterms_is_Part_Of"
WpRna ||--|o WpGeneProduct : "wp_bdb_Hgnc_Symbol"
WpRna ||--|o WpGeneProduct : "wp_bdb_Uniprot"
WpRna ||--|o WpMetabolite : "wp_bdb_Ch_EBI"
WpRna ||--|o WpMetabolite : "wp_bdb_Kegg_Compound"
WpRna ||--|o WpPathway : "dc_identifier"
WpRna ||--|o WpPathway : "wp_bdb_Ensembl"
WpRna ||--|o WpProtein : "wp_bdb_Entrez_Gene"
WpRna ||--|o WpPublicationReference : "dcterms_references"
WpStimulation ||--|o GpmlDataNode : "wp_is_About"
WpStimulation ||--|o WpDataNode : "wp_participants"
WpStimulation ||--|o WpDirectedInteraction : "wp_target"
WpStimulation ||--|o WpRna : "wp_source"
WpTranscriptionTranslation ||--|o WpDataNode : "wp_participants"
WpTranscriptionTranslation ||--|o WpDirectedInteraction : "wp_target"
WpTranslocation ||--|o WpDataNode : "wp_participants"

json_path = os.path.join(exports_path, f"{dataset_name}_schema.json")
csv_path = os.path.join(exports_path, f"{dataset_name}_schema.csv")

# Export CSV from frequencies
frequencies_df.to_csv(csv_path, index=False)

# Export JSON derived from JSON-LD (maintains consistency)
with open(json_path, "w", encoding="utf-8") as fh:
    json.dump(vp.to_json(filter_void_nodes=True), fh, indent=2)

print(f"CSV exported to: {csv_path}")
print(f"JSON exported to: {json_path}")

2026-01-16 14:12:25 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Complex: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:25 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:25 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:25 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#Protein: 'in <string>' requires string as left operand, not NoneType

2026-01-16 14:12:25 DEBUG rdfsolve.parser: Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

DEBUG:rdfsolve.parser:Bioregistry failed for http://vocabularies.wikipathways.org/wp#bdbReactome: 'in <string>' requires string as left operand, not NoneType

# Export collected SPARQL queries as TTL
queries_path = os.path.join(exports_path, f"{dataset_name}_sparql_queries.ttl")
queries = SparqlHelper.get_collected_queries()

if queries:
    ttl_content = SparqlHelper.export_queries_as_ttl(
        output_file=queries_path,
        base_uri=f"https://github.com/jmillanacosta/rdfsolve/sparql/{dataset_name}/",
        dataset_name=dataset_name,
    )
    print(f"Exported {len(queries)} SPARQL queries to: {queries_path}")
else:
    print("No SPARQL queries were collected")

Exported 590 SPARQL queries to: /home/javi/rdfsolve-1/notebooks/01_schema_extraction/../../docs/data/schema_extraction/wikipathways/wikipathways_sparql_queries.ttl

	subject_class	subject_uri	property	property_uri	object_class	object_uri
0	wp:Complex	http://vocabularies.wikipathways.org/wp#Complex	wp:bdbReactome	http://vocabularies.wikipathways.org/wp#bdbRea...	wp:Protein	http://vocabularies.wikipathways.org/wp#Protein
1	wp:Protein	http://vocabularies.wikipathways.org/wp#Protein	wp:bdbReactome	http://vocabularies.wikipathways.org/wp#bdbRea...	wp:Complex	http://vocabularies.wikipathways.org/wp#Complex
2	wp:Metabolite	http://vocabularies.wikipathways.org/wp#Metabo...	wp:bdbReactome	http://vocabularies.wikipathways.org/wp#bdbRea...	wp:Protein	http://vocabularies.wikipathways.org/wp#Protein
3	wp:Interaction	http://vocabularies.wikipathways.org/wp#Intera...	wp:bdbReactome	http://vocabularies.wikipathways.org/wp#bdbRea...	wp:Pathway	http://vocabularies.wikipathways.org/wp#Pathway
4	wp:DataNode	http://vocabularies.wikipathways.org/wp#DataNode	wp:bdbReactome	http://vocabularies.wikipathways.org/wp#bdbRea...	wp:Metabolite	http://vocabularies.wikipathways.org/wp#Metabo...

	subject_class	property	object_class	coverage_percent
248	skos:Collection	foaf:img	foaf:Image	100.0
202	wp:Protein	rdf:type	owl:Class	100.0
56	wp:DirectedInteraction	wp:source	wp:DataNode	100.0
58	wp:Stimulation	wp:source	wp:DataNode	100.0
203	wp:Complex	rdf:type	owl:Class	100.0

wikipathways Schema Extraction¶

Exports¶

Cache Control¶

VoID Discovery¶

Schema Discovery and Exports Workflow¶

Workflow Steps:¶

Schema Pattern Coverage Analysis¶

Schema Pattern Instance Collection¶

LinkML (derived from JSON-LD)¶